# ## 实现思路
#
# 1. 梳理出来 求生和监管两个大类，每个父类应该具有哪些属性和方法。
# 2. 梳理每个父类相对应的子类，以及每个子类应该又哪些属性和方法。
# 3. 梳理游戏流程，按照面向对象的形式实现出来。
# 4. 游戏流程实现出来之后，再实现对应的细节。
#
class Skiller:
    def __init__(self,name):
        self.name = name
        self.skill = SKillFactory.getSkill(name)
    def Skill(self,skiller):
        self.skill(skiller)

class Supervisor(Skiller):
    def __init__(self,name):
        super().__init__(name)
    def beat(self,survivor):
        print(f"监管者{self.name}攻击{survivor.name}")
        survivor.hp -= survivor.hp_upper_limit // 2



class Survivor(Skiller):
    def __init__(self,name,hp):
        self.hp = hp
        self.hp_upper_limit = hp
        super().__init__(name)
    def Run(self):
        print(f'{self.name}在跑')
    def crack_password(self):
        print(f"{self.name}在破译密码机")
    #判断是否倒地
    def is_be_Ko(self):
        if self.hp <= 0:
            print(f"{self.name}倒地")
        else:
            print(f"{self.name}逃跑成功")



class SKillFactory:
    @staticmethod
    def getSkill(skillname):
        skills = {
            "园丁":Generate_shield,
            "医生": Heal,
            "律师":None,
            "红蝶":Skill1,
            "厂长":Skill2,
            "杰克":jiekeSkill
        }
        if skillname in skills.keys():
            return skills[skillname]
        return None
#园丁技能
def Generate_shield(skiller:Skiller):
    print(f"{skiller.name}生成一个护盾")
#红蝶技能
def Skill1(skiller:Skiller):
    print(f'{skiller.name}技能生成')

#厂长技能
def Skill2(skiller: Skiller):
    print(f'{skiller.name}技能生成')
#医生技能
def Heal(survivor :Survivor):
    if survivor.hp_upper_limit == survivor.hp:
        return
    heal_hp = survivor.hp_upper_limit // 4
    if heal_hp + survivor.hp >= survivor.hp_upper_limit:
        survivor.hp = survivor.hp_upper_limit
    else:
        survivor.hp += heal_hp
    print(f"{survivor.name}治疗中")
#杰克技能
def jiekeSkill(survivor :Survivor):
    survivor.hp -= survivor.hp_upper_limit // 2
    print(f"监管者杰克技能攻击{survivor.name}")
#流程1
def Process1():
    survivor1 = Survivor("园丁", 100)
    survivor2 = Survivor("园丁", 100)
    survivor3 = Survivor("医生", 100)
    survivor4 = Survivor("律师", 100)
    supervisor = Supervisor("杰克")
    supervisor.beat(survivor1)
    # 园丁开局碰到了杰克，被杰克普攻命中一次。
    survivor1.is_be_Ko()
    #     2. 园丁逃跑成功，
    supervisor.beat(survivor3)
    print(survivor3.hp)
    survivor3.is_be_Ko()
    survivor3.skill(survivor3)
    print(survivor3.hp)
    #     3. 医生使用技能。
    supervisor.beat(survivor3)
    #     3. 杰克又找到了医生，医生被杰克普攻命中一次。
    supervisor.beat(survivor3)
    print(survivor3.hp)
    #     4. 医生被杰克命中2次，倒地。
    survivor3.is_be_Ko()
def Process2():
    survivor1 = Survivor("园丁", 100)
    survivor2 = Survivor("园丁", 100)
    survivor3 = Survivor("医生", 100)
    survivor4 = Survivor("律师", 100)
    supervisor = Supervisor("杰克")
    supervisor.beat(survivor4)
    supervisor.Skill(survivor4)
    survivor4.is_be_Ko()
    supervisor.beat(survivor1)
    survivor1.is_be_Ko()
    survivor3.skill(survivor1)
    #== = 流程2
    #     1. 律师开局被杰克普攻命中一次，又被技能命中一次，倒地
    #     2. 园丁被杰克普攻命中一次，
    #     3. 园丁逃跑
    #     4. 园丁找到医生，被医生治疗


if __name__ == '__main__':
    print("流程一   start")
    Process1()
    print("流程一  end")
    print("流程2        start")
    Process2()
    print("流程2      end")


# ### 需求
# 2. 监管者有红蝶，厂长，杰克等角色。
#     1. 每个监管者有自己的名称。
#     2. 每个监管都可以进行普通 beat()，
#         每次普攻，如果击中求生者，求生者掉一半的血量。
#     3. 每个监管都有自己的技能，而且每个监管者的技能都不一样
# 3. 求生者有园丁，医生，律师等
#     1. 每个求生者都有自己的血量，名字。
#     2. 每个求生者都有 跑、 破译密码机的能力。
#     3. 每个求生者都有自己的技能，求生可以使用自己的技能。
#         1. 园丁的技能是生成一个护盾，可以抵御监管者的一次普攻
#         2. 医生的技能是自己给自己打针，打一次针可以恢复1/4的血量
#         3. 律师没有特殊技能。
# 4. 游戏开始，需要加载4个求生者，1个监管者。接下来需要实现此代码流程。
#
#
#
#
# 在整个开发过程中，可以自行添加有趣的游戏细节。注意：要使用面向对象的思路进行开发！！！